﻿
#include "Engine/common.h"
#include "DNF定义.h"
#include "DNF对象定义.h"
#include "AppUI.h"

std::vector<DNF技能对象*> 技能对象表;
std::vector<DNF职业对象*> 职业对象表;
std::vector<DNF装备对象*> 装备对象表[装备类型总数];	//id序
std::map<WCHAR*,DNF装备对象*,wstrless_t> 装备对象表_名称[装备类型总数];	//名称序快速查找
DNF职业对象* 当前职业对象;
DNF角色对象* 当前角色对象;
DNF计算核心 计算核心;

void 添加技能对象_奶妈();	
void 添加技能对象_剑帝();
void 添加职业对象_奶妈();
void 添加职业对象_剑帝();

void 添加装备对象_装备1();
void 添加装备对象_装备2();
void 添加装备对象_装备3();
void 添加装备对象_套装();
void 添加装备对象_词条1();
void 添加装备对象_词条2();
void 添加装备对象_词条3();

void 添加装备对象_附魔();
void 添加装备对象_徽章();
void 添加装备对象_武器装扮();
void 添加装备对象_皮肤();
void 添加装备对象_光环();
void 添加装备对象_快捷栏装备();
void 添加装备对象_宠物装备();

void CalcCoreInit()
{
	//初始化技能对象
	添加技能对象_奶妈();
	添加技能对象_剑帝();
	//初始化职业对象
	添加职业对象_奶妈();	
	添加职业对象_剑帝();
	//初始化装备对象
	添加装备对象_装备1();
	添加装备对象_装备2();
	添加装备对象_装备3();
	添加装备对象_套装();
	添加装备对象_词条1();
	添加装备对象_词条2();
	添加装备对象_词条3();

	添加装备对象_附魔();
	添加装备对象_徽章();
	添加装备对象_武器装扮();
	添加装备对象_皮肤();
	添加装备对象_光环();
	添加装备对象_快捷栏装备();
	添加装备对象_宠物装备();

	//生成名称表
	for (int i=0;i<装备类型总数;i++)
	{
		//以索引查找，名字无意义
		if (i==词条类)
			continue;
		std::vector<DNF装备对象*>::iterator it;
		for (it=装备对象表[i].begin();it!=装备对象表[i].end();it++)
		{
			DNF装备对象* 装备对象=*it;
			if (装备对象!=NULL)
			{
				if (i==装备类)	//装备类的名称从[DNF装备名称]取
					装备对象表_名称[i].insert(std::make_pair(DNF装备名称[装备对象->装备Id],装备对象));
				else if (i==套装类)	//装备类的名称从[DNF套装名称]取
					装备对象表_名称[i].insert(std::make_pair(DNF套装名称[装备对象->装备Id],装备对象));
				else
					装备对象表_名称[i].insert(std::make_pair(装备对象->名称,装备对象));
			}
		}
	}
	//初始化角色对象
	当前角色对象=new DNF角色对象;
	当前角色对象->初始化();
	for (int i=0;i<装备对象表[套装类].size();i++)		//数量必须等于[套装数量]，否则索引会出错
		当前角色对象->初始化套装对象(i,(装备对象表[套装类])[i]);
	//初始化计算核心对象
	计算核心.初始化();
}

void CalcCoreUnInit()
{
	//清理技能对象
	std::vector<DNF技能对象*>::iterator it;
	for (it=技能对象表.begin();it!=技能对象表.end();it++)
		delete (*it);
	//清理职业对象
	std::vector<DNF职业对象*>::iterator it2;
	for (it2=职业对象表.begin();it2!=职业对象表.end();it2++)
		delete (*it2);
	//清理装备对象
	for (int i=0;i<装备类型总数;i++)
	{
		std::vector<DNF装备对象*>::iterator it;
		for (it=装备对象表[i].begin();it!=装备对象表[i].end();it++)
		{
			if ((*it)!=NULL)	//有一些占位的空装备
				delete (*it);
		}
		装备对象表[i].clear();
		//名称表全是指针引用，只要clear就行了
		装备对象表_名称[i].clear();
	}
	//清理角色对象
	当前角色对象->反初始化();
	delete 当前角色对象;
	//清理计算核心对象
	计算核心.反初始化();
}

void CalcCoreChangeJob(int JobIndex)
{
	if (JobIndex!=-1)
	{
		伤害计算结果.Init();
		std::vector<DNF职业对象*>::iterator it;
		for (it=职业对象表.begin();it!=职业对象表.end();it++)
		{
			if ((*it)->职业==JobIndex)
			{
				当前职业对象=*it;
				break;
			}
		}
	}
	else
	{
		伤害计算结果.Uninit();
		当前职业对象=NULL;
	}
}

void CalcCoreDoCalculation()
{
	计算核心.重置();
	计算核心.执行计算();

	for (int i=0;i<DNF计算核心::属性结果总数;i++)
		伤害计算结果.属性结果[i]=计算核心.属性结果[i];
	伤害计算结果.系统奶=计算核心.系统奶;
	伤害计算结果.总伤害=计算核心.总伤害;

	伤害计算结果.技能结果数=计算核心.技能结果数;
	for (int i=0;i<计算核心.技能结果数;i++)
	{
		int 技能索引=计算核心.技能结果[i].技能索引;
		伤害计算结果.技能结果[i].技能图标Id=当前职业对象->职业技能列表[技能索引]->ResId;
		伤害计算结果.技能结果[i].技能等级=计算核心.技能结果[i].技能等级;
		伤害计算结果.技能结果[i].技能次数=计算核心.技能结果[i].技能次数;
		伤害计算结果.技能结果[i].技能冷却时间=计算核心.技能结果[i].技能冷却时间;
		伤害计算结果.技能结果[i].技能平均伤害=计算核心.技能结果[i].技能平均伤害;
		伤害计算结果.技能结果[i].技能总伤害=计算核心.技能结果[i].技能总伤害;
		伤害计算结果.技能结果[i].技能占比=计算核心.技能结果[i].技能占比;
	}

	伤害计算结果.技能冷却结果数=计算核心.技能冷却结果数;
	for (int i=0;i<计算核心.技能冷却结果数;i++)
	{
		int 技能索引=计算核心.技能冷却结果[i].技能索引;
		伤害计算结果.技能冷却结果[i].技能图标Id=当前职业对象->职业技能列表[技能索引]->ResId;
		伤害计算结果.技能冷却结果[i].技能原始时间=计算核心.技能冷却结果[i].技能原始时间;
		伤害计算结果.技能冷却结果[i].技能当前时间=计算核心.技能冷却结果[i].技能当前时间;
		伤害计算结果.技能冷却结果[i].技能缩减率=计算核心.技能冷却结果[i].技能缩减率;
		伤害计算结果.技能冷却结果[i].技能无色数=计算核心.技能冷却结果[i].技能无色数;
	}

	伤害计算结果.被动技能数=计算核心.被动技能数;
	for (int i=0;i<计算核心.被动技能数;i++)
	{
		int 技能索引=计算核心.被动技能结果[i].技能索引;
		伤害计算结果.被动技能结果[i].技能图标Id=当前职业对象->职业技能列表[技能索引]->ResId;
		伤害计算结果.被动技能结果[i].技能等级=计算核心.被动技能结果[i].技能等级;
	}

	for (int i=0;i<全部装备部位总数;i++)
	{
		伤害计算结果.装备结果[i].打造物攻加成=计算核心.装备结果[i].打造物攻加成;
		伤害计算结果.装备结果[i].打造魔攻加成=计算核心.装备结果[i].打造魔攻加成;
		伤害计算结果.装备结果[i].打造独立加成=计算核心.装备结果[i].打造独立加成;
		伤害计算结果.装备结果[i].打造四维加成=计算核心.装备结果[i].打造四维加成;
		伤害计算结果.装备结果[i].锻造独立加成=计算核心.装备结果[i].锻造独立加成;
		伤害计算结果.装备结果[i].满足条件=计算核心.装备结果[i].满足条件;
		wcscpy(伤害计算结果.装备结果[i].条件描述,计算核心.装备结果[i].条件描述);
	}

	伤害计算结果.Sort();
}